If you have been following along thus far in our Lean Laundry series, bless your heart. Hopefully you have gotten a few laughs, learned how large batch sizes can really mess things up, and reduced your sock defect backlog. In this blog we are going to take a look at how my wife and I’s laundry saga applies to shipping software. So let’s get started!

It’s been 3 years since the smaller laundry baskets arrived at my wife and I’s house. Our laundry woes have largely diminished but from time to time we “decide” it would be a good idea to drop a power plant pull request…I mean do a big batch of laundry.

Inevitably that causes some pain and frustration for everyone involved. The pain usually manifests itself through sorting/merge conflicts, rabbit hunting and troubleshooting, and generally delaying other clothing items from getting merged into our laundry branch. So how might we prevent this from happening? I’m glad you asked! 🙂

To answer that let’s honor the day this blog is being published and do a little #TBT to our laundry debacle.

The Great Laundry Debacle

My wife and I made a critical decision that drove a lot of downstream problems. After struggling to keep up with large batches of laundry we decided to add extra capacity to our laundry system in the form of super-sized laundry baskets. We assumed this would help our laundry problem.

In reality it exacerbated the problem. In the previous blog we described how these huge batches of laundry caused the following problems:

1. Long cycle times – It took a really long time for a single clothing item to be clean.
2. Large inventory – long wait times caused us to buy more clothes.
3. Hidden inventory – we didn’t even realize how large our inventory of clothes was because they were normally buried in our super-sized laundry baskets.
4. Unfinished work – our laundry lay around our house in various states (dirty, sorted, washed, dried, and folded)
5. Troubleshooting – when we were in need of a specific clothing item, we often had to search through various piles of unfinished laundry.

All of this was a result of trying to manage large batch sizes. The interesting thing is large batch sizes usually lead to even larger batch sizes – a death spiral if you will. Managing software from commit through deployment is no different. All along the way we are managing batches of work. Batches can take the form of:

• Changes accepted but not deployed
• Changes tested but not accepted
• Changes merged but not tested
• Changes reviewed but not merged
• Changes completed but not reviewed
• Changes in progress but not completed

All of these batches must be managed well in order to keep value flowing through development to end users. This largely means managing batches.

The Challenge in Software

The hard thing in software is most of these batches (a.k.a. software inventory) are hidden from view. My laundry was laying around the house in plain sight. However, most software inventory is either in your head or on a hard drive. Therefore it’s easy for inventory to pile up at any one of the above stages leading to the same exact problems we discovered in our large batch laundry system.

So back to the original question…

How do we prevent this from happening?

First – make EVERYTHING visible

We have to make our inventory visible. We can’t manage what we can’t see. Therefore use tools that will make work in progress visible. This includes:

• Backlog management tools
• Visible task boards
• Build & test reports
• Your deployment pipeline cycle time

These tools help to identify inventory pileups or bottlenecks in our development process.

Second – if it hurts…do it more often!

Profound stuff…right?!?! This is a principle in the Continuous Delivery book.

Laundry was really painful. The ultimate answer was to do it more, which meant smaller batches of laundry. When we brought the pain forward, laundry became a routine event and our laundry mechanics dramatically improved.

No longer did my wife raise an eyebrow after seeing my asymmetrical folding jobs. Through regular practice, I now have department store folding skills.

Similarly, shipping software doesn’t need to raise the eyebrow of your stakeholders. Here’s some more profound advice:

• If merging code is hard, do it more often.
• If regression testing your system is painful, do it more often.
• If planning work is difficult, do it more often
• If deploying software is painful, do it more often.

Bringing the pain forward will not only develop a ‘muscle memory’ response to a once painful activity, but you will also figure out ways to innovate through the pain. Why? Because you will get annoyed with inconsistent, laborious tasks that you were once willing to deal with only when done infrequently. But once the frequency of doing these painful tasks picks up, you’ll need to figure out a more efficient way of doing them.

These improvements are what enable software teams to sustainably manage smaller batches of work. Here are some practical ways to sustainably do just that:

Identify repetitive, manual tasks and automate them. Machines are great at performing these kinds of tasks. Humans tend to be error prone and slow. Some examples:

• System versioning
• Build management
• Most forms of testing
• Deployments
• Environment management
• Monitoring

Investing in Clean Coding practices will drive down the pain associated with maintaining and extending an existing system (which is every system). After all if we automate shipping cowboy code, we’ll just ship sloppy changes that much faster. Considering the following while writing code will help rope in everyone’s inner cowboy:

• Readability
• Testability
• Cohesion
• Coupling
• Redundancy
• Encapsulation

Parting Thoughts

While laundry is far less complex than shipping software, it is something we can all relate with as it simplifies common problems found in software development. Given the complexity difference there is a lot more we could expand on, but we’ll save that for another time.

At the end of the day batch sizes drive a lot of behavior. Managing them down is key to shipping software fast with confidence.

I’m sure your software team has some extra laundry laying around. So grab your fellow brogrammer or broettegrammer and figure out how you can invest in some “smaller baskets”!